/**
 * 立即颜色修复工具
 * 强制修复场景中所有黑色透明材质的颜色问题
 */

export class ImmediateColorFixer {
    /**
     * 立即修复场景中所有材质的颜色问题
     * @param {THREE.Scene} scene - Three.js场景对象
     */
    static forceFixAllColors(scene) {
        console.log('\n🚨 强制修复所有材质颜色问题...\n');
        
        let totalMaterials = 0;
        let fixedMaterials = 0;
        let transparentMaterials = 0;
        
        scene.traverse((obj) => {
            if (obj.isMesh && obj.material) {
                const materials = Array.isArray(obj.material) ? obj.material : [obj.material];
                
                materials.forEach((mat, index) => {
                    totalMaterials++;
                    
                    const isTransparent = mat.transparent || mat.alphaTest > 0 || mat.opacity < 1;
                    
                    if (isTransparent) {
                        transparentMaterials++;
                        
                        // 检查颜色
                        const isBlack = mat.color && (
                            mat.color.r === 0 && mat.color.g === 0 && mat.color.b === 0
                        );
                        
                        const isDark = mat.color && (
                            mat.color.r < 0.1 && mat.color.g < 0.1 && mat.color.b < 0.1
                        );
                        
                        if (isBlack || isDark) {
                            console.log(`🔧 强制修复材质颜色: ${obj.name || '(unnamed)'} - 材质${index}`);
                            console.log(`   修复前: RGB(${mat.color.r.toFixed(3)}, ${mat.color.g.toFixed(3)}, ${mat.color.b.toFixed(3)})`);
                            
                            // 强制设置为白色
                            mat.color.setRGB(1, 1, 1);
                            mat.needsUpdate = true;
                            
                            console.log(`   修复后: RGB(${mat.color.r.toFixed(3)}, ${mat.color.g.toFixed(3)}, ${mat.color.b.toFixed(3)})`);
                            fixedMaterials++;
                        }
                        
                        // 额外检查：确保透明参数正确
                        const meshName = (obj.name || '').toLowerCase();
                        const isRoadLine = meshName.includes('road') || meshName.includes('line') || 
                                         meshName.includes('马路') || meshName.includes('线');
                        
                        if (isRoadLine) {
                            // 马路线应该使用alphaTest模式
                            if (mat.transparent === true) {
                                console.log(`🛣️ 修正马路线透明模式: ${obj.name}`);
                                mat.transparent = false;
                                mat.alphaTest = 0.5;
                                mat.depthWrite = true;
                                mat.needsUpdate = true;
                            }
                        }
                    }
                });
            }
        });
        
        console.log(`\n✅ 强制修复完成！`);
        console.log(`   总材质数: ${totalMaterials}`);
        console.log(`   透明材质: ${transparentMaterials}`);
        console.log(`   修复颜色: ${fixedMaterials}`);
        
        if (fixedMaterials > 0) {
            console.log(`\n🎯 如果问题仍然存在，可能需要检查贴图本身是否有问题`);
        }
        
        return {
            totalMaterials,
            transparentMaterials,
            fixedMaterials
        };
    }
    
    /**
     * 详细检查材质状态
     */
    static detailedCheck(scene) {
        console.log('\n🔍 详细材质状态检查...\n');
        
        scene.traverse((obj) => {
            if (obj.isMesh && obj.material) {
                const materials = Array.isArray(obj.material) ? obj.material : [obj.material];
                
                materials.forEach((mat, index) => {
                    const isTransparent = mat.transparent || mat.alphaTest > 0 || mat.opacity < 1;
                    
                    if (isTransparent) {
                        console.log(`📋 透明材质: ${obj.name || '(unnamed)'} - 材质${index}`);
                        console.log(`   类型: ${mat.type}`);
                        console.log(`   颜色: RGB(${mat.color.r.toFixed(3)}, ${mat.color.g.toFixed(3)}, ${mat.color.b.toFixed(3)})`);
                        console.log(`   透明设置: transparent=${mat.transparent}, alphaTest=${mat.alphaTest}, opacity=${mat.opacity}`);
                        console.log(`   深度设置: depthWrite=${mat.depthWrite}, depthTest=${mat.depthTest}`);
                        console.log(`   贴图: map=${!!mat.map}, alphaMap=${!!mat.alphaMap}`);
                        console.log(`   渲染顺序: ${obj.renderOrder}`);
                        
                        // 检查贴图信息
                        if (mat.map) {
                            console.log(`   主贴图: ${mat.map.image?.src || '未知'}`);
                        }
                        if (mat.alphaMap) {
                            console.log(`   透明贴图: ${mat.alphaMap.image?.src || '未知'}`);
                        }
                        
                        console.log('');
                    }
                });
            }
        });
    }
}

// 创建便捷实例
const immediateColorFixer = {
    // 强制修复所有颜色问题
    forcefix: () => {
        const scene = window.manager?.getCurrentScene()?.scene;
        if (!scene) {
            console.error('❌ 场景未加载');
            return;
        }
        return ImmediateColorFixer.forceFixAllColors(scene);
    },
    
    // 详细检查
    detail: () => {
        const scene = window.manager?.getCurrentScene()?.scene;
        if (!scene) {
            console.error('❌ 场景未加载');
            return;
        }
        return ImmediateColorFixer.detailedCheck(scene);
    }
};

// 暴露到全局
window.immediateColorFixer = immediateColorFixer;

export default immediateColorFixer;
